package com.augrain.microframework.core.util;

import org.slf4j.helpers.MessageFormatter;

import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串相关工具类
 *
 * @author biaoy
 * @since 2020/11/25
 */
public class StringUtils {

    private StringUtils() {

    }

    /**
     * 空字符判断
     */
    public static boolean isEmpty(String str) {
        return str == null || "".equals(str);
    }

    /**
     * 是否是空白字符
     */
    public static boolean isBlank(String str) {
        return str == null || "".equals(str) || "".equals(str.trim());
    }

    /**
     * 非空判断
     */
    public static boolean isNotEmpty(String str) {
        return !isEmpty(str);
    }

    /**
     * 是否是空白字符
     */
    public static boolean isNotBlank(String str) {
        return !isBlank(str);
    }

    /**
     * null转空字符串
     */
    public static String nullToEmpty(String str) {
        if (str == null) {
            return "";
        }
        return str;
    }

    /**
     * 空字符串转默认值
     */
    public static String emptyToDefault(String str, String def) {
        if (isEmpty(str)) {
            return def;
        }
        return str;
    }

    /**
     * 前置填充， 例如 num =1 空位为0 总长为10 结果为0000000001
     */
    public static String fillEmpty(long num, char c, int length) {
        String numStr = String.valueOf(num);
        int numLen = numStr.length();
        if (numLen >= length) {
            return numStr.substring(numLen - length);
        }
        StringBuilder sb = new StringBuilder(length);
        while (sb.length() < length - numLen) {
            sb.append(c);
        }
        sb.append(numStr);
        return sb.toString();
    }

    /**
     * 去掉首字符串和未字符串
     *
     * @param str      字符串
     * @param startStr 首串
     * @param endStr   尾串
     */
    public static String removeStartEnd(String str, String startStr, String endStr) {
        return removeEnd(removeStart(str, startStr), endStr);
    }

    /**
     * 去掉末尾字符串
     */
    public static String removeEnd(String str, String endStr) {
        if (str == null) {
            return null;
        }
        if (!str.endsWith(endStr)) {
            return str;
        }
        return str.substring(0, str.lastIndexOf(endStr));
    }

    /**
     * 去掉首字符串
     */
    public static String removeStart(String str, String startStr) {
        if (str == null) {
            return null;
        }
        if (!str.startsWith(startStr)) {
            return str;
        }
        return str.substring(str.indexOf(startStr) + startStr.length());
    }

    /**
     * 分隔字符串
     *
     * @param str   字符串
     * @param split 分隔符
     * @return 使用分隔符拆分后，组装成List返回
     */
    public static List<String> split(String str, String split) {
        String[] strs = str.split(split);
        return new ArrayList<>(Arrays.asList(strs));
    }

    /**
     * 集合转字符串
     *
     * @param list  集合对象
     * @param split 分隔符
     * @return 将集合对象使用分隔符，组装成String返回
     */
    public static String join(Collection<String> list, String split) {
        if (list == null || list.size() == 0) {
            return "";
        }
        String splitToUse = split;
        if (splitToUse == null) {
            splitToUse = ",";
        }
        return String.join(splitToUse, list);
    }

    /**
     * 数组join成字符串
     *
     * @param array 数组
     * @param split 分隔符
     * @return 将数组对象使用分隔符，组装成String返回
     */
    public static String join(String[] array, String split) {
        if (array == null || array.length == 0) {
            return "";
        }
        String splitToUse = split;
        if (splitToUse == null) {
            splitToUse = ",";
        }
        return String.join(splitToUse, array);
    }

    /**
     * 寻找出符合起始标志和结束标志的字串组
     *
     * @param str       字符串源
     * @param startSign 起始标志
     * @param endSign   结束标志
     */
    public static List<String> findPairs(String str, String startSign, String endSign) {
        List<String> l = new LinkedList<>();
        int c = 0;
        while ((c = str.indexOf(startSign, c + 1)) >= 0) {
            int ce = str.indexOf(endSign, c);
            if (ce > 0) {
                l.add(str.substring(c, ce) + endSign);
            }
        }
        return l;
    }

    /**
     * 寻找匹配项,返回List
     *
     * @param str   字符串
     * @param regex 正则式
     */
    public static List<String> findMatches(String str, String regex) {
        List<String> l = new LinkedList<>();
        Matcher m = Pattern.compile(regex).matcher(str);
        while (m.find()) {
            l.add(m.group());
        }
        return l;
    }

    public static String fillEmptyWithStr(long num, int length, String str) {
        String strNum = String.valueOf(num);
        int numLen = strNum.length();
        if (numLen > length) {
            return strNum.substring(numLen - length);
        } else {
            String repeat = getRepeatStrs(str, length - numLen);
            return repeat + strNum;
        }
    }

    public static String getRepeatStrs(String repeatStr, int repeatCount) {
        if (repeatCount <= 0) {
            return "";
        } else {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < repeatCount; ++i) {
                sb.append(repeatStr);
            }
            return sb.toString();
        }
    }

    /**
     * 格式化字符串，使用{}作为占位符
     *
     * @param msg  字符串模板
     * @param args 模板参数
     * @return 格式化后的字符串
     */
    public static String format(String msg, Object... args) {
        return MessageFormatter.arrayFormat(msg, args).getMessage();
    }

    /**
     * 字符串左侧，以固定内容填充到指定长度
     *
     * @param msg     原始字符串
     * @param fillStr 填充字符串
     * @param length  填充的长度
     * @return 返回填充指定字符串后的结果
     */
    public static String leftPad(String msg, String fillStr, int length) {
        if (isEmpty(fillStr)) {
            throw new RuntimeException("填充字符串不能为空");
        }

        if (msg != null && msg.length() >= length) {
            return msg;
        }

        int msgLength = msg == null ? 0 : msg.length();
        // 填充内容长度
        int fillLength = length - msgLength;
        // 循环次数
        int repeatCount = fillLength / fillStr.length();
        // 截取长度
        int splitCount = fillLength % fillStr.length();

        StringBuilder fill = new StringBuilder();
        for (int i = 0; i < repeatCount; i++) {
            fill.append(fillStr);
        }
        if (splitCount > 0) {
            fill.append(fillStr, 0, splitCount);
        }
        return fill + msg;
    }

    public static String repeat(char character, int times) {
        char[] buffer = new char[times];
        Arrays.fill(buffer, character);
        return new String(buffer);
    }
}
